package constants

import (
	"jvm/instructions/base"
	"jvm/rtda"
	. "jvm/typedef"
)

// 全是入栈指令 入栈元素为指令自带或指令码后的操作数
// **********************************************************
// nop
type NOP struct {
	base.NoOperandsInst
}

func (self *NOP) Execute(frame *rtda.Frame) {

}

// **********************************************************
// 将null推入操作数栈
type ACONST_NULL struct {
	base.NoOperandsInst
}

func (self *ACONST_NULL) Execute(frame *rtda.Frame) {
	frame.OPStack().PushRef(nil)
}

// **********************************************************
// 将double型的0.0推入操作数栈
type DCONST_0 struct {
	base.NoOperandsInst
}

func (self *DCONST_0) Execute(frame *rtda.Frame) {
	frame.OPStack().PushDouble(0.0)
}

// **********************************************************
// 将double型的1.0推入操作数栈
type DCONST_1 struct {
	base.NoOperandsInst
}

func (self *DCONST_1) Execute(frame *rtda.Frame) {
	frame.OPStack().PushDouble(1.0)
}

// **********************************************************
// 将float型的0.0推入操作数栈
type FCONST_0 struct {
	base.NoOperandsInst
}

func (self *FCONST_0) Execute(frame *rtda.Frame) {
	frame.OPStack().PushFloat(0.0)
}

// **********************************************************
// 将float型的1.0推入操作数栈
type FCONST_1 struct {
	base.NoOperandsInst
}

func (self *FCONST_1) Execute(frame *rtda.Frame) {
	frame.OPStack().PushFloat(1.0)
}

// **********************************************************
// 将float型的2.0推入操作数栈
type FCONST_2 struct {
	base.NoOperandsInst
}

func (self *FCONST_2) Execute(frame *rtda.Frame) {
	frame.OPStack().PushFloat(2.0)
}

// **********************************************************
// 将int型的-1推入操作数栈
type ICONST_M1 struct {
	base.NoOperandsInst
}

func (self *ICONST_M1) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(-1)
}

// **********************************************************
// 将int型的0推入操作数栈
type ICONST_0 struct {
	base.NoOperandsInst
}

func (self *ICONST_0) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(0)
} // **********************************************************
// 将int型的1推入操作数栈
type ICONST_1 struct {
	base.NoOperandsInst
}

func (self *ICONST_1) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(1)
} // **********************************************************
// 将int型的2推入操作数栈
type ICONST_2 struct {
	base.NoOperandsInst
}

func (self *ICONST_2) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(2)
} // **********************************************************
// 将int型的3推入操作数栈
type ICONST_3 struct {
	base.NoOperandsInst
}

func (self *ICONST_3) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(3)
} // **********************************************************
// 将int型的4推入操作数栈
type ICONST_4 struct {
	base.NoOperandsInst
}

func (self *ICONST_4) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(4)
}

// **********************************************************
// 将int型的-1推入操作数栈
type ICONST_5 struct {
	base.NoOperandsInst
}

func (self *ICONST_5) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(5)
}

// **********************************************************
// 将long型的0推入操作数栈
type LCONST_0 struct {
	base.NoOperandsInst
}

func (self *LCONST_0) Execute(frame *rtda.Frame) {
	frame.OPStack().PushLong(0)
}

// **********************************************************
// 将long型的1推入操作数栈
type LCONST_1 struct {
	base.NoOperandsInst
}

func (self *LCONST_1) Execute(frame *rtda.Frame) {
	frame.OPStack().PushLong(1)
}

// **********************************************************
// 从指令码后读一个byte型整数，扩展为int型，推入栈顶
type BIPUSH struct {
	val I1
}

func (self *BIPUSH) ReadOperands(reader *base.CodeReader) {
	self.val = reader.ReadI1()
}

func (self *BIPUSH) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(I4(self.val))
}

// **********************************************************
// 从指令码后读一个byte型整数，扩展为int型，推入栈顶
type SIPUSH struct {
	val I2
}

func (self *SIPUSH) ReadOperands(reader *base.CodeReader) {
	self.val = reader.ReadI2()
}

func (self *SIPUSH) Execute(frame *rtda.Frame) {
	frame.OPStack().PushInt(I4(self.val))
}
